home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 2001 May / SGI Freeware 2001 May - Disc 3.iso / dist / fw_openssl.idb / usr / freeware / include / openssl / crypto.h.z / crypto.h
Encoding:
C/C++ Source or Header  |  2001-01-10  |  14.9 KB  |  401 lines
  1. /* crypto/crypto.h */
  2. /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  3.  * All rights reserved.
  4.  *
  5.  * This package is an SSL implementation written
  6.  * by Eric Young (eay@cryptsoft.com).
  7.  * The implementation was written so as to conform with Netscapes SSL.
  8.  * 
  9.  * This library is free for commercial and non-commercial use as long as
  10.  * the following conditions are aheared to.  The following conditions
  11.  * apply to all code found in this distribution, be it the RC4, RSA,
  12.  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  13.  * included with this distribution is covered by the same copyright terms
  14.  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  15.  * 
  16.  * Copyright remains Eric Young's, and as such any Copyright notices in
  17.  * the code are not to be removed.
  18.  * If this package is used in a product, Eric Young should be given attribution
  19.  * as the author of the parts of the library used.
  20.  * This can be in the form of a textual message at program startup or
  21.  * in documentation (online or textual) provided with the package.
  22.  * 
  23.  * Redistribution and use in source and binary forms, with or without
  24.  * modification, are permitted provided that the following conditions
  25.  * are met:
  26.  * 1. Redistributions of source code must retain the copyright
  27.  *    notice, this list of conditions and the following disclaimer.
  28.  * 2. Redistributions in binary form must reproduce the above copyright
  29.  *    notice, this list of conditions and the following disclaimer in the
  30.  *    documentation and/or other materials provided with the distribution.
  31.  * 3. All advertising materials mentioning features or use of this software
  32.  *    must display the following acknowledgement:
  33.  *    "This product includes cryptographic software written by
  34.  *     Eric Young (eay@cryptsoft.com)"
  35.  *    The word 'cryptographic' can be left out if the rouines from the library
  36.  *    being used are not cryptographic related :-).
  37.  * 4. If you include any Windows specific code (or a derivative thereof) from 
  38.  *    the apps directory (application code) you must include an acknowledgement:
  39.  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  40.  * 
  41.  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  42.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  45.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51.  * SUCH DAMAGE.
  52.  * 
  53.  * The licence and distribution terms for any publically available version or
  54.  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  55.  * copied and put under another distribution licence
  56.  * [including the GNU Public Licence.]
  57.  */
  58.  
  59. #ifndef HEADER_CRYPTO_H
  60. #define HEADER_CRYPTO_H
  61.  
  62. #include <stdlib.h>
  63.  
  64. #ifndef NO_FP_API
  65. #include <stdio.h>
  66. #endif
  67.  
  68. #include <openssl/stack.h>
  69. #include <openssl/safestack.h>
  70. #include <openssl/opensslv.h>
  71.  
  72. #ifdef CHARSET_EBCDIC
  73. #include <openssl/ebcdic.h>
  74. #endif
  75.  
  76. /* Resolve problems on some operating systems with symbol names that clash
  77.    one way or another */
  78. #include <openssl/symhacks.h>
  79.  
  80. #ifdef  __cplusplus
  81. extern "C" {
  82. #endif
  83.  
  84. /* Backward compatibility to SSLeay */
  85. /* This is more to be used to check the correct DLL is being used
  86.  * in the MS world. */
  87. #define SSLEAY_VERSION_NUMBER    OPENSSL_VERSION_NUMBER
  88. #define SSLEAY_VERSION        0
  89. /* #define SSLEAY_OPTIONS    1 no longer supported */
  90. #define SSLEAY_CFLAGS        2
  91. #define SSLEAY_BUILT_ON        3
  92. #define SSLEAY_PLATFORM        4
  93.  
  94. /* When changing the CRYPTO_LOCK_* list, be sure to maintin the text lock
  95.  * names in cryptlib.c
  96.  */
  97.  
  98. #define    CRYPTO_LOCK_ERR            1
  99. #define    CRYPTO_LOCK_ERR_HASH        2
  100. #define    CRYPTO_LOCK_X509        3
  101. #define    CRYPTO_LOCK_X509_INFO        4
  102. #define    CRYPTO_LOCK_X509_PKEY        5
  103. #define CRYPTO_LOCK_X509_CRL        6
  104. #define CRYPTO_LOCK_X509_REQ        7
  105. #define CRYPTO_LOCK_DSA            8
  106. #define CRYPTO_LOCK_RSA            9
  107. #define CRYPTO_LOCK_EVP_PKEY        10
  108. #define    CRYPTO_LOCK_X509_STORE        11
  109. #define    CRYPTO_LOCK_SSL_CTX        12
  110. #define    CRYPTO_LOCK_SSL_CERT        13
  111. #define    CRYPTO_LOCK_SSL_SESSION        14
  112. #define    CRYPTO_LOCK_SSL_SESS_CERT    15
  113. #define    CRYPTO_LOCK_SSL            16
  114. #define    CRYPTO_LOCK_RAND        17
  115. #define    CRYPTO_LOCK_MALLOC        18
  116. #define    CRYPTO_LOCK_BIO            19
  117. #define    CRYPTO_LOCK_GETHOSTBYNAME    20
  118. #define    CRYPTO_LOCK_GETSERVBYNAME    21
  119. #define    CRYPTO_LOCK_READDIR        22
  120. #define    CRYPTO_LOCK_RSA_BLINDING    23
  121. #define    CRYPTO_LOCK_DH            24
  122. #define    CRYPTO_LOCK_MALLOC2        25
  123. #define    CRYPTO_LOCK_DSO            26
  124. #define    CRYPTO_LOCK_DYNLOCK        27
  125. #define    CRYPTO_NUM_LOCKS        28
  126.  
  127. #define CRYPTO_LOCK        1
  128. #define CRYPTO_UNLOCK        2
  129. #define CRYPTO_READ        4
  130. #define CRYPTO_WRITE        8
  131.  
  132. #ifndef NO_LOCKING
  133. #ifndef CRYPTO_w_lock
  134. #define CRYPTO_w_lock(type)    \
  135.     CRYPTO_lock(CRYPTO_LOCK|CRYPTO_WRITE,type,__FILE__,__LINE__)
  136. #define CRYPTO_w_unlock(type)    \
  137.     CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_WRITE,type,__FILE__,__LINE__)
  138. #define CRYPTO_r_lock(type)    \
  139.     CRYPTO_lock(CRYPTO_LOCK|CRYPTO_READ,type,__FILE__,__LINE__)
  140. #define CRYPTO_r_unlock(type)    \
  141.     CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_READ,type,__FILE__,__LINE__)
  142. #define CRYPTO_add(addr,amount,type)    \
  143.     CRYPTO_add_lock(addr,amount,type,__FILE__,__LINE__)
  144. #endif
  145. #else
  146. #define CRYPTO_w_lock(a)
  147. #define    CRYPTO_w_unlock(a)
  148. #define CRYPTO_r_lock(a)
  149. #define CRYPTO_r_unlock(a)
  150. #define CRYPTO_add(a,b,c)    ((*(a))+=(b))
  151. #endif
  152.  
  153. /* Some applications as well as some parts of OpenSSL need to allocate
  154.    and deallocate locks in a dynamic fashion.  The following typedef
  155.    makes this possible in a type-safe manner.  */
  156. /* struct CRYPTO_dynlock_value has to be defined by the application. */
  157. typedef struct
  158.     {
  159.     int references;
  160.     struct CRYPTO_dynlock_value *data;
  161.     } CRYPTO_dynlock;
  162.  
  163.  
  164. /* The following can be used to detect memory leaks in the SSLeay library.
  165.  * It used, it turns on malloc checking */
  166.  
  167. #define CRYPTO_MEM_CHECK_OFF    0x0    /* an enume */
  168. #define CRYPTO_MEM_CHECK_ON    0x1    /* a bit */
  169. #define CRYPTO_MEM_CHECK_ENABLE    0x2    /* a bit */
  170. #define CRYPTO_MEM_CHECK_DISABLE 0x3    /* an enume */
  171.  
  172. /* The following are bit values to turn on or off options connected to the
  173.  * malloc checking functionality */
  174.  
  175. /* Adds time to the memory checking information */
  176. #define V_CRYPTO_MDEBUG_TIME    0x1 /* a bit */
  177. /* Adds thread number to the memory checking information */
  178. #define V_CRYPTO_MDEBUG_THREAD    0x2 /* a bit */
  179.  
  180. #define V_CRYPTO_MDEBUG_ALL (V_CRYPTO_MDEBUG_TIME | V_CRYPTO_MDEBUG_THREAD)
  181.  
  182.  
  183. /* predec of the BIO type */
  184. typedef struct bio_st BIO_dummy;
  185.  
  186. typedef struct crypto_ex_data_st
  187.     {
  188.     STACK *sk;
  189.     int dummy; /* gcc is screwing up this data structure :-( */
  190.     } CRYPTO_EX_DATA;
  191.  
  192. /* Called when a new object is created */
  193. typedef int CRYPTO_EX_new(void *parent, void *ptr, CRYPTO_EX_DATA *ad,
  194.                     int idx, long argl, void *argp);
  195. /* Called when an object is free()ed */
  196. typedef void CRYPTO_EX_free(void *parent, void *ptr, CRYPTO_EX_DATA *ad,
  197.                     int idx, long argl, void *argp);
  198. /* Called when we need to dup an object */
  199. typedef int CRYPTO_EX_dup(CRYPTO_EX_DATA *to, CRYPTO_EX_DATA *from, void *from_d, 
  200.                     int idx, long argl, void *argp);
  201.  
  202. /* This stuff is basically class callback functions
  203.  * The current classes are SSL_CTX, SSL, SSL_SESSION, and a few more */
  204.  
  205. typedef struct crypto_ex_data_func_st
  206.     {
  207.     long argl;    /* Arbitary long */
  208.     void *argp;    /* Arbitary void * */
  209.     CRYPTO_EX_new *new_func;
  210.     CRYPTO_EX_free *free_func;
  211.     CRYPTO_EX_dup *dup_func;
  212.     } CRYPTO_EX_DATA_FUNCS;
  213.  
  214. DECLARE_STACK_OF(CRYPTO_EX_DATA_FUNCS)
  215.  
  216. /* Per class, we have a STACK of CRYPTO_EX_DATA_FUNCS for each CRYPTO_EX_DATA
  217.  * entry.
  218.  */
  219.  
  220. #define CRYPTO_EX_INDEX_BIO        0
  221. #define CRYPTO_EX_INDEX_SSL        1
  222. #define CRYPTO_EX_INDEX_SSL_CTX        2
  223. #define CRYPTO_EX_INDEX_SSL_SESSION    3
  224. #define CRYPTO_EX_INDEX_X509_STORE    4
  225. #define CRYPTO_EX_INDEX_X509_STORE_CTX    5
  226.  
  227.  
  228. /* This is the default callbacks, but we can have others as well:
  229.  * this is needed in Win32 where the application malloc and the
  230.  * library malloc may not be the same.
  231.  */
  232. #define CRYPTO_malloc_init()    CRYPTO_set_mem_functions(\
  233.     malloc, realloc, free)
  234.  
  235. #if defined CRYPTO_MDEBUG_ALL || defined CRYPTO_MDEBUG_TIME || defined CRYPTO_MDEBUG_THREAD
  236. # ifndef CRYPTO_MDEBUG /* avoid duplicate #define */
  237. #  define CRYPTO_MDEBUG
  238. # endif
  239. #endif
  240.  
  241. /* Set standard debugging functions (not done by default
  242.  * unless CRYPTO_MDEBUG is defined) */
  243. #define CRYPTO_malloc_debug_init()    do {\
  244.     CRYPTO_set_mem_debug_functions(\
  245.         CRYPTO_dbg_malloc,\
  246.         CRYPTO_dbg_realloc,\
  247.         CRYPTO_dbg_free,\
  248.         CRYPTO_dbg_set_options,\
  249.         CRYPTO_dbg_get_options);\
  250.     } while(0)
  251.  
  252. int CRYPTO_mem_ctrl(int mode);
  253. int CRYPTO_is_mem_check_on(void);
  254.  
  255. /* for applications */
  256. #define MemCheck_start() CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON)
  257. #define MemCheck_stop()    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_OFF)
  258.  
  259. /* for library-internal use */
  260. #define MemCheck_on()    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE)
  261. #define MemCheck_off()    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE)
  262. #define is_MemCheck_on() CRYPTO_is_mem_check_on()
  263.  
  264. #define OPENSSL_malloc(num)    CRYPTO_malloc((int)num,__FILE__,__LINE__)
  265. #define OPENSSL_realloc(addr,num) \
  266.     CRYPTO_realloc((char *)addr,(int)num,__FILE__,__LINE__)
  267. #define OPENSSL_remalloc(addr,num) \
  268.     CRYPTO_remalloc((char **)addr,(int)num,__FILE__,__LINE__)
  269. #define OPENSSL_freeFunc    CRYPTO_free
  270. #define OPENSSL_free(addr)    CRYPTO_free(addr)
  271.  
  272. #define OPENSSL_malloc_locked(num) \
  273.     CRYPTO_malloc_locked((int)num,__FILE__,__LINE__)
  274. #define OPENSSL_free_locked(addr) CRYPTO_free_locked(addr)
  275.  
  276.  
  277. const char *SSLeay_version(int type);
  278. unsigned long SSLeay(void);
  279.  
  280. int CRYPTO_get_ex_new_index(int idx, STACK_OF(CRYPTO_EX_DATA_FUNCS) **skp, long argl, void *argp,
  281.          CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func);
  282. int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *val);
  283. void *CRYPTO_get_ex_data(CRYPTO_EX_DATA *ad,int idx);
  284. int CRYPTO_dup_ex_data(STACK_OF(CRYPTO_EX_DATA_FUNCS) *meth, CRYPTO_EX_DATA *to,
  285.          CRYPTO_EX_DATA *from);
  286. void CRYPTO_free_ex_data(STACK_OF(CRYPTO_EX_DATA_FUNCS) *meth, void *obj, CRYPTO_EX_DATA *ad);
  287. void CRYPTO_new_ex_data(STACK_OF(CRYPTO_EX_DATA_FUNCS) *meth, void *obj, CRYPTO_EX_DATA *ad);
  288.  
  289. int CRYPTO_get_new_lockid(char *name);
  290.  
  291. int CRYPTO_num_locks(void); /* return CRYPTO_NUM_LOCKS (shared libs!) */
  292. void CRYPTO_lock(int mode, int type,const char *file,int line);
  293. void CRYPTO_set_locking_callback(void (*func)(int mode,int type,
  294.                           const char *file,int line));
  295. void (*CRYPTO_get_locking_callback(void))(int mode,int type,const char *file,
  296.         int line);
  297. void CRYPTO_set_add_lock_callback(int (*func)(int *num,int mount,int type,
  298.                           const char *file, int line));
  299. int (*CRYPTO_get_add_lock_callback(void))(int *num,int mount,int type,
  300.                       const char *file,int line);
  301. void CRYPTO_set_id_callback(unsigned long (*func)(void));
  302. unsigned long (*CRYPTO_get_id_callback(void))(void);
  303. unsigned long CRYPTO_thread_id(void);
  304. const char *CRYPTO_get_lock_name(int type);
  305. int CRYPTO_add_lock(int *pointer,int amount,int type, const char *file,
  306.             int line);
  307.  
  308. int CRYPTO_get_new_dynlockid(void);
  309. void CRYPTO_destroy_dynlockid(int i);
  310. struct CRYPTO_dynlock_value *CRYPTO_get_dynlock_value(int i);
  311. void CRYPTO_set_dynlock_create_callback(struct CRYPTO_dynlock_value *(*dyn_create_function)(const char *file, int line));
  312. void CRYPTO_set_dynlock_lock_callback(void (*dyn_lock_function)(int mode, struct CRYPTO_dynlock_value *l, const char *file, int line));
  313. void CRYPTO_set_dynlock_destroy_callback(void (*dyn_destroy_function)(struct CRYPTO_dynlock_value *l, const char *file, int line));
  314. struct CRYPTO_dynlock_value *(*CRYPTO_get_dynlock_create_callback(void))(const char *file,int line);
  315. void (*CRYPTO_get_dynlock_lock_callback(void))(int mode, struct CRYPTO_dynlock_value *l, const char *file,int line);
  316. void (*CRYPTO_get_dynlock_destroy_callback(void))(struct CRYPTO_dynlock_value *l, const char *file,int line);
  317.  
  318. /* CRYPTO_set_mem_functions includes CRYPTO_set_locked_mem_functions --
  319.  * call the latter last if you need different functions */
  320. int CRYPTO_set_mem_functions(void *(*m)(size_t),void *(*r)(void *,size_t), void (*f)(void *));
  321. int CRYPTO_set_locked_mem_functions(void *(*m)(size_t), void (*free_func)(void *));
  322. int CRYPTO_set_mem_debug_functions(void (*m)(void *,int,const char *,int,int),
  323.                    void (*r)(void *,void *,int,const char *,int,int),
  324.                    void (*f)(void *,int),
  325.                    void (*so)(long),
  326.                    long (*go)(void));
  327. void CRYPTO_get_mem_functions(void *(**m)(size_t),void *(**r)(void *, size_t), void (**f)(void *));
  328. void CRYPTO_get_locked_mem_functions(void *(**m)(size_t), void (**f)(void *));
  329. void CRYPTO_get_mem_debug_functions(void (**m)(void *,int,const char *,int,int),
  330.                     void (**r)(void *,void *,int,const char *,int,int),
  331.                     void (**f)(void *,int),
  332.                     void (**so)(long),
  333.                     long (**go)(void));
  334.  
  335. void *CRYPTO_malloc_locked(int num, const char *file, int line);
  336. void CRYPTO_free_locked(void *);
  337. void *CRYPTO_malloc(int num, const char *file, int line);
  338. void CRYPTO_free(void *);
  339. void *CRYPTO_realloc(void *addr,int num, const char *file, int line);
  340. void *CRYPTO_remalloc(void *addr,int num, const char *file, int line);
  341.  
  342. void CRYPTO_set_mem_debug_options(long bits);
  343. long CRYPTO_get_mem_debug_options(void);
  344.  
  345. #define CRYPTO_push_info(info) \
  346.         CRYPTO_push_info_(info, __FILE__, __LINE__);
  347. int CRYPTO_push_info_(const char *info, const char *file, int line);
  348. int CRYPTO_pop_info(void);
  349. int CRYPTO_remove_all_info(void);
  350.  
  351. /* The last argument has the following significance:
  352.  *
  353.  * 0:    called before the actual memory allocation has taken place
  354.  * 1:    called after the actual memory allocation has taken place
  355.  */
  356. void CRYPTO_dbg_malloc(void *addr,int num,const char *file,int line,int before_p);
  357. void CRYPTO_dbg_realloc(void *addr1,void *addr2,int num,const char *file,int line,int before_p);
  358. void CRYPTO_dbg_free(void *addr,int before_p);
  359.  
  360. /* Tell the debugging code about options.  By default, the following values
  361.  * apply:
  362.  *
  363.  * 0:    Clear all options.
  364.  * 1:    Set the "Show Time" option.
  365.  * 2:    Set the "Show Thread Number" option.
  366.  * 3:    1 + 2
  367.  */
  368. void CRYPTO_dbg_set_options(long bits);
  369. long CRYPTO_dbg_get_options(void);
  370.  
  371. #ifndef NO_FP_API
  372. void CRYPTO_mem_leaks_fp(FILE *);
  373. #endif
  374. void CRYPTO_mem_leaks(struct bio_st *bio);
  375. /* unsigned long order, char *file, int line, int num_bytes, char *addr */
  376. void CRYPTO_mem_leaks_cb(void (*cb)(unsigned long, const char *, int, int, void *));
  377.  
  378. void ERR_load_CRYPTO_strings(void);
  379.  
  380. /* BEGIN ERROR CODES */
  381. /* The following lines are auto generated by the script mkerr.pl. Any changes
  382.  * made after this point may be overwritten when the script is next run.
  383.  */
  384.  
  385. /* Error codes for the CRYPTO functions. */
  386.  
  387. /* Function codes. */
  388. #define CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX         100
  389. #define CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID         103
  390. #define CRYPTO_F_CRYPTO_GET_NEW_LOCKID             101
  391. #define CRYPTO_F_CRYPTO_SET_EX_DATA             102
  392.  
  393. /* Reason codes. */
  394. #define CRYPTO_R_NO_DYNLOCK_CREATE_CALLBACK         100
  395.  
  396. #ifdef  __cplusplus
  397. }
  398. #endif
  399. #endif
  400.  
  401.